home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / test / test_builtin.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2005-10-18  |  49.2 KB  |  1,701 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. import test.test_support as test
  5. import unittest
  6. from test.test_support import fcmp, have_unicode, TESTFN, unlink
  7. import sys
  8. import warnings
  9. import cStringIO
  10. import random
  11. import UserDict
  12. warnings.filterwarnings('ignore', 'hex../oct.. of negative int', FutureWarning, __name__)
  13. warnings.filterwarnings('ignore', 'integer argument expected', DeprecationWarning, 'unittest')
  14.  
  15. class Squares:
  16.     
  17.     def __init__(self, max):
  18.         self.max = max
  19.         self.sofar = []
  20.  
  21.     
  22.     def __len__(self):
  23.         return len(self.sofar)
  24.  
  25.     
  26.     def __getitem__(self, i):
  27.         if i <= i:
  28.             pass
  29.         elif not i < self.max:
  30.             raise IndexError
  31.         
  32.         n = len(self.sofar)
  33.         while n <= i:
  34.             self.sofar.append(n * n)
  35.             n += 1
  36.             continue
  37.             0
  38.         return self.sofar[i]
  39.  
  40.  
  41.  
  42. class StrSquares:
  43.     
  44.     def __init__(self, max):
  45.         self.max = max
  46.         self.sofar = []
  47.  
  48.     
  49.     def __len__(self):
  50.         return len(self.sofar)
  51.  
  52.     
  53.     def __getitem__(self, i):
  54.         if i <= i:
  55.             pass
  56.         elif not i < self.max:
  57.             raise IndexError
  58.         
  59.         n = len(self.sofar)
  60.         while n <= i:
  61.             self.sofar.append(str(n * n))
  62.             n += 1
  63.             continue
  64.             0
  65.         return self.sofar[i]
  66.  
  67.  
  68.  
  69. class BitBucket:
  70.     
  71.     def write(self, line):
  72.         pass
  73.  
  74.  
  75. L = [
  76.     ('0', 0),
  77.     ('1', 1),
  78.     ('9', 9),
  79.     ('10', 10),
  80.     ('99', 99),
  81.     ('100', 100),
  82.     ('314', 314),
  83.     (' 314', 314),
  84.     ('314 ', 314),
  85.     ('  \t\t  314  \t\t  ', 314),
  86.     (repr(sys.maxint), sys.maxint),
  87.     ('  1x', ValueError),
  88.     ('  1  ', 1),
  89.     ('  1\x02  ', ValueError),
  90.     ('', ValueError),
  91.     (' ', ValueError),
  92.     ('  \t\t  ', ValueError)]
  93. if have_unicode:
  94.     L += [
  95.         (unicode('0'), 0),
  96.         (unicode('1'), 1),
  97.         (unicode('9'), 9),
  98.         (unicode('10'), 10),
  99.         (unicode('99'), 99),
  100.         (unicode('100'), 100),
  101.         (unicode('314'), 314),
  102.         (unicode(' 314'), 314),
  103.         (unicode('\\u0663\\u0661\\u0664 ', 'raw-unicode-escape'), 314),
  104.         (unicode('  \t\t  314  \t\t  '), 314),
  105.         (unicode('  1x'), ValueError),
  106.         (unicode('  1  '), 1),
  107.         (unicode('  1\x02  '), ValueError),
  108.         (unicode(''), ValueError),
  109.         (unicode(' '), ValueError),
  110.         (unicode('  \t\t  '), ValueError),
  111.         (unichr(512), ValueError)]
  112.  
  113.  
  114. class BuiltinTest(unittest.TestCase):
  115.     
  116.     def test_import(self):
  117.         __import__('sys')
  118.         __import__('time')
  119.         __import__('string')
  120.         self.assertRaises(ImportError, __import__, 'spamspam')
  121.         self.assertRaises(TypeError, __import__, 1, 2, 3, 4)
  122.  
  123.     
  124.     def test_abs(self):
  125.         self.assertEqual(abs(0), 0)
  126.         self.assertEqual(abs(1234), 1234)
  127.         self.assertEqual(abs(-1234), 1234)
  128.         self.assertEqual(abs(0.0), 0.0)
  129.         self.assertEqual(abs(3.1400000000000001), 3.1400000000000001)
  130.         self.assertEqual(abs(-3.1400000000000001), 3.1400000000000001)
  131.         self.assertEqual(abs(0x0L), 0x0L)
  132.         self.assertEqual(abs(0x4D2L), 0x4D2L)
  133.         self.assertEqual(abs(-0x4D2L), 0x4D2L)
  134.         self.assertRaises(TypeError, abs, 'a')
  135.  
  136.     
  137.     def test_apply(self):
  138.         
  139.         def f0(*args):
  140.             self.assertEqual(args, ())
  141.  
  142.         
  143.         def f1(a1):
  144.             self.assertEqual(a1, 1)
  145.  
  146.         
  147.         def f2(a1, a2):
  148.             self.assertEqual(a1, 1)
  149.             self.assertEqual(a2, 2)
  150.  
  151.         
  152.         def f3(a1, a2, a3):
  153.             self.assertEqual(a1, 1)
  154.             self.assertEqual(a2, 2)
  155.             self.assertEqual(a3, 3)
  156.  
  157.         apply(f0, ())
  158.         apply(f1, (1,))
  159.         apply(f2, (1, 2))
  160.         apply(f3, (1, 2, 3))
  161.         apply(id, (1,), { })
  162.         self.assertRaises(TypeError, apply, id, (1,), {
  163.             'foo': 1 })
  164.         self.assertRaises(TypeError, apply)
  165.         self.assertRaises(TypeError, apply, id, 42)
  166.         self.assertRaises(TypeError, apply, id, (42,), 42)
  167.  
  168.     
  169.     def test_callable(self):
  170.         self.assert_(callable(len))
  171.         
  172.         def f():
  173.             pass
  174.  
  175.         self.assert_(callable(f))
  176.         
  177.         class C:
  178.             
  179.             def meth(self):
  180.                 pass
  181.  
  182.  
  183.         self.assert_(callable(C))
  184.         x = C()
  185.         self.assert_(callable(x.meth))
  186.         self.assert_(not callable(x))
  187.         
  188.         class D(C):
  189.             
  190.             def __call__(self):
  191.                 pass
  192.  
  193.  
  194.         y = D()
  195.         self.assert_(callable(y))
  196.         y()
  197.  
  198.     
  199.     def test_chr(self):
  200.         self.assertEqual(chr(32), ' ')
  201.         self.assertEqual(chr(65), 'A')
  202.         self.assertEqual(chr(97), 'a')
  203.         self.assertEqual(chr(255), '\xff')
  204.         self.assertRaises(ValueError, chr, 256)
  205.         self.assertRaises(TypeError, chr)
  206.  
  207.     
  208.     def test_cmp(self):
  209.         self.assertEqual(cmp(-1, 1), -1)
  210.         self.assertEqual(cmp(1, -1), 1)
  211.         self.assertEqual(cmp(1, 1), 0)
  212.         a = []
  213.         a.append(a)
  214.         b = []
  215.         b.append(b)
  216.         UserList = UserList
  217.         import UserList
  218.         c = UserList()
  219.         c.append(c)
  220.         self.assertRaises(RuntimeError, cmp, a, b)
  221.         self.assertRaises(RuntimeError, cmp, b, c)
  222.         self.assertRaises(RuntimeError, cmp, c, a)
  223.         self.assertRaises(RuntimeError, cmp, a, c)
  224.         a.pop()
  225.         b.pop()
  226.         c.pop()
  227.         self.assertRaises(TypeError, cmp)
  228.  
  229.     
  230.     def test_coerce(self):
  231.         self.assert_(not fcmp(coerce(1, 1.1000000000000001), (1.0, 1.1000000000000001)))
  232.         self.assertEqual(coerce(1, 0x1L), (0x1L, 0x1L))
  233.         self.assert_(not fcmp(coerce(0x1L, 1.1000000000000001), (1.0, 1.1000000000000001)))
  234.         self.assertRaises(TypeError, coerce)
  235.         
  236.         class BadNumber:
  237.             
  238.             def __coerce__(self, other):
  239.                 raise ValueError
  240.  
  241.  
  242.         self.assertRaises(ValueError, coerce, 42, BadNumber())
  243.         self.assertRaises(OverflowError, coerce, 0.5, int('12345' * 1000))
  244.  
  245.     
  246.     def test_compile(self):
  247.         compile('print 1\n', '', 'exec')
  248.         bom = '\xef\xbb\xbf'
  249.         compile(bom + 'print 1\n', '', 'exec')
  250.         self.assertRaises(TypeError, compile)
  251.         self.assertRaises(ValueError, compile, 'print 42\n', '<string>', 'badmode')
  252.         self.assertRaises(ValueError, compile, 'print 42\n', '<string>', 'single', 255)
  253.         if have_unicode:
  254.             compile(unicode('print u"\xc3\xa5"\n', 'utf8'), '', 'exec')
  255.         
  256.  
  257.     
  258.     def test_delattr(self):
  259.         import sys
  260.         sys.spam = 1
  261.         delattr(sys, 'spam')
  262.         self.assertRaises(TypeError, delattr)
  263.  
  264.     
  265.     def test_dir(self):
  266.         x = 1
  267.         self.assert_('x' in dir())
  268.         import sys
  269.         self.assert_('modules' in dir(sys))
  270.         self.assertRaises(TypeError, dir, 42, 42)
  271.  
  272.     
  273.     def test_divmod(self):
  274.         self.assertEqual(divmod(12, 7), (1, 5))
  275.         self.assertEqual(divmod(-12, 7), (-2, 2))
  276.         self.assertEqual(divmod(12, -7), (-2, -2))
  277.         self.assertEqual(divmod(-12, -7), (1, -5))
  278.         self.assertEqual(divmod(0xCL, 0x7L), (0x1L, 0x5L))
  279.         self.assertEqual(divmod(-0xCL, 0x7L), (-0x2L, 0x2L))
  280.         self.assertEqual(divmod(0xCL, -0x7L), (-0x2L, -0x2L))
  281.         self.assertEqual(divmod(-0xCL, -0x7L), (0x1L, -0x5L))
  282.         self.assertEqual(divmod(12, 0x7L), (1, 0x5L))
  283.         self.assertEqual(divmod(-12, 0x7L), (-2, 0x2L))
  284.         self.assertEqual(divmod(0xCL, -7), (-0x2L, -2))
  285.         self.assertEqual(divmod(-0xCL, -7), (0x1L, -5))
  286.         self.assertEqual(divmod(-(sys.maxint) - 1, -1), (sys.maxint + 1, 0))
  287.         self.assert_(not fcmp(divmod(3.25, 1.0), (3.0, 0.25)))
  288.         self.assert_(not fcmp(divmod(-3.25, 1.0), (-4.0, 0.75)))
  289.         self.assert_(not fcmp(divmod(3.25, -1.0), (-4.0, -0.75)))
  290.         self.assert_(not fcmp(divmod(-3.25, -1.0), (3.0, -0.25)))
  291.         self.assertRaises(TypeError, divmod)
  292.  
  293.     
  294.     def test_eval(self):
  295.         self.assertEqual(eval('1+1'), 2)
  296.         self.assertEqual(eval(' 1+1\n'), 2)
  297.         globals = {
  298.             'a': 1,
  299.             'b': 2 }
  300.         locals = {
  301.             'b': 200,
  302.             'c': 300 }
  303.         self.assertEqual(eval('a', globals), 1)
  304.         self.assertEqual(eval('a', globals, locals), 1)
  305.         self.assertEqual(eval('b', globals, locals), 200)
  306.         self.assertEqual(eval('c', globals, locals), 300)
  307.         if have_unicode:
  308.             self.assertEqual(eval(unicode('1+1')), 2)
  309.             self.assertEqual(eval(unicode(' 1+1\n')), 2)
  310.         
  311.         globals = {
  312.             'a': 1,
  313.             'b': 2 }
  314.         locals = {
  315.             'b': 200,
  316.             'c': 300 }
  317.         if have_unicode:
  318.             self.assertEqual(eval(unicode('a'), globals), 1)
  319.             self.assertEqual(eval(unicode('a'), globals, locals), 1)
  320.             self.assertEqual(eval(unicode('b'), globals, locals), 200)
  321.             self.assertEqual(eval(unicode('c'), globals, locals), 300)
  322.             bom = '\xef\xbb\xbf'
  323.             self.assertEqual(eval(bom + 'a', globals, locals), 1)
  324.             self.assertEqual(eval(unicode('u"\xc3\xa5"', 'utf8'), globals), unicode('\xc3\xa5', 'utf8'))
  325.         
  326.         self.assertRaises(TypeError, eval)
  327.         self.assertRaises(TypeError, eval, ())
  328.  
  329.     
  330.     def test_general_eval(self):
  331.         
  332.         class M:
  333.             '''Test mapping interface versus possible calls from eval().'''
  334.             
  335.             def __getitem__(self, key):
  336.                 if key == 'a':
  337.                     return 12
  338.                 
  339.                 raise KeyError
  340.  
  341.             
  342.             def keys(self):
  343.                 return list('xyz')
  344.  
  345.  
  346.         m = M()
  347.         g = globals()
  348.         self.assertEqual(eval('a', g, m), 12)
  349.         self.assertRaises(NameError, eval, 'b', g, m)
  350.         self.assertEqual(eval('dir()', g, m), list('xyz'))
  351.         self.assertEqual(eval('globals()', g, m), g)
  352.         self.assertEqual(eval('locals()', g, m), m)
  353.         self.assertRaises(TypeError, eval, 'a', m)
  354.         
  355.         class A:
  356.             '''Non-mapping'''
  357.             pass
  358.  
  359.         m = A()
  360.         self.assertRaises(TypeError, eval, 'a', g, m)
  361.         
  362.         class D(dict):
  363.             
  364.             def __getitem__(self, key):
  365.                 if key == 'a':
  366.                     return 12
  367.                 
  368.                 return dict.__getitem__(self, key)
  369.  
  370.             
  371.             def keys(self):
  372.                 return list('xyz')
  373.  
  374.  
  375.         d = D()
  376.         self.assertEqual(eval('a', g, d), 12)
  377.         self.assertRaises(NameError, eval, 'b', g, d)
  378.         self.assertEqual(eval('dir()', g, d), list('xyz'))
  379.         self.assertEqual(eval('globals()', g, d), g)
  380.         self.assertEqual(eval('locals()', g, d), d)
  381.         eval('[locals() for i in (2,3)]', g, d)
  382.         eval('[locals() for i in (2,3)]', g, UserDict.UserDict())
  383.         
  384.         class SpreadSheet:
  385.             '''Sample application showing nested, calculated lookups.'''
  386.             _cells = { }
  387.             
  388.             def __setitem__(self, key, formula):
  389.                 self._cells[key] = formula
  390.  
  391.             
  392.             def __getitem__(self, key):
  393.                 return eval(self._cells[key], globals(), self)
  394.  
  395.  
  396.         ss = SpreadSheet()
  397.         ss['a1'] = '5'
  398.         ss['a2'] = 'a1*6'
  399.         ss['a3'] = 'a2*7'
  400.         self.assertEqual(ss['a3'], 210)
  401.         
  402.         class C:
  403.             
  404.             def __getitem__(self, item):
  405.                 raise KeyError(item)
  406.  
  407.             
  408.             def keys(self):
  409.                 return 'a'
  410.  
  411.  
  412.         self.assertRaises(TypeError, eval, 'dir()', globals(), C())
  413.  
  414.     z = 0
  415.     f = open(TESTFN, 'w')
  416.     f.write('z = z+1\n')
  417.     f.write('z = z*2\n')
  418.     f.close()
  419.     execfile(TESTFN)
  420.     
  421.     def test_execfile(self):
  422.         globals = {
  423.             'a': 1,
  424.             'b': 2 }
  425.         locals = {
  426.             'b': 200,
  427.             'c': 300 }
  428.         self.assertEqual(self.__class__.z, 2)
  429.         globals['z'] = 0
  430.         execfile(TESTFN, globals)
  431.         self.assertEqual(globals['z'], 2)
  432.         locals['z'] = 0
  433.         execfile(TESTFN, globals, locals)
  434.         self.assertEqual(locals['z'], 2)
  435.         
  436.         class M:
  437.             '''Test mapping interface versus possible calls from execfile().'''
  438.             
  439.             def __init__(self):
  440.                 self.z = 10
  441.  
  442.             
  443.             def __getitem__(self, key):
  444.                 if key == 'z':
  445.                     return self.z
  446.                 
  447.                 raise KeyError
  448.  
  449.             
  450.             def __setitem__(self, key, value):
  451.                 if key == 'z':
  452.                     self.z = value
  453.                     return None
  454.                 
  455.                 raise KeyError
  456.  
  457.  
  458.         locals = M()
  459.         locals['z'] = 0
  460.         execfile(TESTFN, globals, locals)
  461.         self.assertEqual(locals['z'], 2)
  462.         unlink(TESTFN)
  463.         self.assertRaises(TypeError, execfile)
  464.         import os
  465.         self.assertRaises(IOError, execfile, os.curdir)
  466.         self.assertRaises(IOError, execfile, 'I_dont_exist')
  467.  
  468.     
  469.     def test_filter(self):
  470.         self.assertEqual(filter((lambda c: None if c <= c else c <= 'z'), 'Hello World'), 'elloorld')
  471.         self.assertEqual(filter(None, [
  472.             1,
  473.             'hello',
  474.             [],
  475.             [
  476.                 3],
  477.             '',
  478.             None,
  479.             9,
  480.             0]), [
  481.             1,
  482.             'hello',
  483.             [
  484.                 3],
  485.             9])
  486.         self.assertEqual(filter((lambda x: x > 0), [
  487.             1,
  488.             -3,
  489.             9,
  490.             0,
  491.             2]), [
  492.             1,
  493.             9,
  494.             2])
  495.         self.assertEqual(filter(None, Squares(10)), [
  496.             1,
  497.             4,
  498.             9,
  499.             16,
  500.             25,
  501.             36,
  502.             49,
  503.             64,
  504.             81])
  505.         self.assertEqual(filter((lambda x: x % 2), Squares(10)), [
  506.             1,
  507.             9,
  508.             25,
  509.             49,
  510.             81])
  511.         
  512.         def identity(item):
  513.             return 1
  514.  
  515.         filter(identity, Squares(5))
  516.         self.assertRaises(TypeError, filter)
  517.         
  518.         class BadSeq(object):
  519.             
  520.             def __getitem__(self, index):
  521.                 if index < 4:
  522.                     return 42
  523.                 
  524.                 raise ValueError
  525.  
  526.  
  527.         self.assertRaises(ValueError, filter, (lambda x: x), BadSeq())
  528.         
  529.         def badfunc():
  530.             pass
  531.  
  532.         self.assertRaises(TypeError, filter, badfunc, range(5))
  533.         self.assertEqual(filter(None, (1, 2)), (1, 2))
  534.         self.assertEqual(filter((lambda x: x >= 3), (1, 2, 3, 4)), (3, 4))
  535.         self.assertRaises(TypeError, filter, 42, (1, 2))
  536.         self.assertEqual(filter(None, '12'), '12')
  537.         self.assertEqual(filter((lambda x: x >= '3'), '1234'), '34')
  538.         self.assertRaises(TypeError, filter, 42, '12')
  539.         
  540.         class badstr(str):
  541.             
  542.             def __getitem__(self, index):
  543.                 raise ValueError
  544.  
  545.  
  546.         self.assertRaises(ValueError, filter, (lambda x: x >= '3'), badstr('1234'))
  547.         
  548.         class badstr2(str):
  549.             
  550.             def __getitem__(self, index):
  551.                 return 42
  552.  
  553.  
  554.         self.assertRaises(TypeError, filter, (lambda x: x >= 42), badstr2('1234'))
  555.         
  556.         class weirdstr(str):
  557.             
  558.             def __getitem__(self, index):
  559.                 return weirdstr(2 * str.__getitem__(self, index))
  560.  
  561.  
  562.         self.assertEqual(filter((lambda x: x >= '33'), weirdstr('1234')), '3344')
  563.         
  564.         class shiftstr(str):
  565.             
  566.             def __getitem__(self, index):
  567.                 return chr(ord(str.__getitem__(self, index)) + 1)
  568.  
  569.  
  570.         self.assertEqual(filter((lambda x: x >= '3'), shiftstr('1234')), '345')
  571.         if have_unicode:
  572.             self.assertEqual(filter(None, unicode('12')), unicode('12'))
  573.             self.assertEqual(filter((lambda x: x >= '3'), unicode('1234')), unicode('34'))
  574.             self.assertRaises(TypeError, filter, 42, unicode('12'))
  575.             self.assertRaises(ValueError, filter, (lambda x: x >= '3'), badstr(unicode('1234')))
  576.             
  577.             class badunicode(unicode):
  578.                 
  579.                 def __getitem__(self, index):
  580.                     return 42
  581.  
  582.  
  583.             self.assertRaises(TypeError, filter, (lambda x: x >= 42), badunicode('1234'))
  584.             
  585.             class weirdunicode(unicode):
  586.                 
  587.                 def __getitem__(self, index):
  588.                     return weirdunicode(2 * unicode.__getitem__(self, index))
  589.  
  590.  
  591.             self.assertEqual(filter((lambda x: x >= unicode('33')), weirdunicode('1234')), unicode('3344'))
  592.             
  593.             class shiftunicode(unicode):
  594.                 
  595.                 def __getitem__(self, index):
  596.                     return unichr(ord(unicode.__getitem__(self, index)) + 1)
  597.  
  598.  
  599.             self.assertEqual(filter((lambda x: x >= unicode('3')), shiftunicode('1234')), unicode('345'))
  600.         
  601.  
  602.     
  603.     def test_filter_subclasses(self):
  604.         funcs = (None, bool, (lambda x: True))
  605.         
  606.         class tuple2(tuple):
  607.             
  608.             def __getitem__(self, index):
  609.                 return 2 * tuple.__getitem__(self, index)
  610.  
  611.  
  612.         
  613.         class str2(str):
  614.             
  615.             def __getitem__(self, index):
  616.                 return 2 * str.__getitem__(self, index)
  617.  
  618.  
  619.         inputs = {
  620.             tuple2: {
  621.                 (): (),
  622.                 (1, 2, 3): (2, 4, 6) },
  623.             str2: {
  624.                 '': '',
  625.                 '123': '112233' } }
  626.         if have_unicode:
  627.             
  628.             class unicode2(unicode):
  629.                 
  630.                 def __getitem__(self, index):
  631.                     return 2 * unicode.__getitem__(self, index)
  632.  
  633.  
  634.             inputs[unicode2] = {
  635.                 unicode(): unicode(),
  636.                 unicode('123'): unicode('112233') }
  637.         
  638.         for cls, inps in inputs.iteritems():
  639.             for inp, exp in inps.iteritems():
  640.                 self.assertEqual(filter(funcs[0], cls(inp)), filter(funcs[1], cls(inp)))
  641.                 for func in funcs:
  642.                     outp = filter(func, cls(inp))
  643.                     self.assertEqual(outp, exp)
  644.                     self.assert_(not isinstance(outp, cls))
  645.                 
  646.             
  647.         
  648.  
  649.     
  650.     def test_float(self):
  651.         self.assertEqual(float(3.1400000000000001), 3.1400000000000001)
  652.         self.assertEqual(float(314), 314.0)
  653.         self.assertEqual(float(0x13AL), 314.0)
  654.         self.assertEqual(float('  3.14  '), 3.1400000000000001)
  655.         if have_unicode:
  656.             self.assertEqual(float(unicode('  3.14  ')), 3.1400000000000001)
  657.             self.assertEqual(float(unicode('  \\u0663.\\u0661\\u0664  ', 'raw-unicode-escape')), 3.1400000000000001)
  658.         
  659.  
  660.     
  661.     def test_getattr(self):
  662.         import sys
  663.         self.assert_(getattr(sys, 'stdout') is sys.stdout)
  664.         self.assertRaises(TypeError, getattr, sys, 1)
  665.         self.assertRaises(TypeError, getattr, sys, 1, 'foo')
  666.         self.assertRaises(TypeError, getattr)
  667.         self.assertRaises(UnicodeError, getattr, sys, unichr(sys.maxunicode))
  668.  
  669.     
  670.     def test_hasattr(self):
  671.         import sys
  672.         self.assert_(hasattr(sys, 'stdout'))
  673.         self.assertRaises(TypeError, hasattr, sys, 1)
  674.         self.assertRaises(TypeError, hasattr)
  675.         self.assertRaises(UnicodeError, hasattr, sys, unichr(sys.maxunicode))
  676.  
  677.     
  678.     def test_hash(self):
  679.         hash(None)
  680.         self.assertEqual(hash(1), hash(0x1L))
  681.         self.assertEqual(hash(1), hash(1.0))
  682.         hash('spam')
  683.         if have_unicode:
  684.             self.assertEqual(hash('spam'), hash(unicode('spam')))
  685.         
  686.         hash((0, 1, 2, 3))
  687.         
  688.         def f():
  689.             pass
  690.  
  691.         self.assertRaises(TypeError, hash, [])
  692.         self.assertRaises(TypeError, hash, { })
  693.  
  694.     
  695.     def test_hex(self):
  696.         self.assertEqual(hex(16), '0x10')
  697.         self.assertEqual(hex(0x10L), '0x10L')
  698.         self.assertEqual(hex(-16), '-0x10')
  699.         self.assertEqual(hex(-0x10L), '-0x10L')
  700.         self.assertRaises(TypeError, hex, { })
  701.  
  702.     
  703.     def test_id(self):
  704.         id(None)
  705.         id(1)
  706.         id(0x1L)
  707.         id(1.0)
  708.         id('spam')
  709.         id((0, 1, 2, 3))
  710.         id([
  711.             0,
  712.             1,
  713.             2,
  714.             3])
  715.         id({
  716.             'spam': 1,
  717.             'eggs': 2,
  718.             'ham': 3 })
  719.  
  720.     
  721.     def test_int(self):
  722.         self.assertEqual(int(314), 314)
  723.         self.assertEqual(int(3.1400000000000001), 3)
  724.         self.assertEqual(int(0x13AL), 314)
  725.         self.assertEqual(int(-3.1400000000000001), -3)
  726.         self.assertEqual(int(3.8999999999999999), 3)
  727.         self.assertEqual(int(-3.8999999999999999), -3)
  728.         self.assertEqual(int(3.5), 3)
  729.         self.assertEqual(int(-3.5), -3)
  730.         self.assertEqual(int('10', 16), 0x10L)
  731.         if have_unicode:
  732.             self.assertEqual(int(unicode('10'), 16), 0x10L)
  733.         
  734.         for s, v in L:
  735.             for sign in ('', '+', '-'):
  736.                 for prefix in ('', ' ', '\t', '  \t\t  '):
  737.                     ss = prefix + sign + s
  738.                     vv = v
  739.                     if sign == '-' and v is not ValueError:
  740.                         vv = -v
  741.                     
  742.                     
  743.                     try:
  744.                         self.assertEqual(int(ss), vv)
  745.                     continue
  746.                     except v:
  747.                         continue
  748.                     
  749.  
  750.                 
  751.             
  752.         
  753.         s = repr(-1 - sys.maxint)
  754.         self.assertEqual(int(s) + 1, -(sys.maxint))
  755.         int(s[1:])
  756.         x = int(1e+100)
  757.         self.assert_(isinstance(x, long))
  758.         x = int(-1e+100)
  759.         self.assert_(isinstance(x, long))
  760.         x = -1 - sys.maxint
  761.         self.assertEqual(x >> 1, x // 2)
  762.         self.assertRaises(ValueError, int, '123\x00')
  763.         self.assertRaises(ValueError, int, '53', 40)
  764.         x = int('1' * 600)
  765.         self.assert_(isinstance(x, long))
  766.         if have_unicode:
  767.             x = int(unichr(1633) * 600)
  768.             self.assert_(isinstance(x, long))
  769.         
  770.         self.assertRaises(TypeError, int, 1, 12)
  771.         self.assertEqual(int('0123', 0), 83)
  772.  
  773.     
  774.     def test_intern(self):
  775.         self.assertRaises(TypeError, intern)
  776.         s = 'never interned before'
  777.         self.assert_(intern(s) is s)
  778.         s2 = s.swapcase().swapcase()
  779.         self.assert_(intern(s2) is s)
  780.         
  781.         class S(str):
  782.             
  783.             def __hash__(self):
  784.                 return 123
  785.  
  786.  
  787.         self.assertRaises(TypeError, intern, S('abc'))
  788.         s = S('abc')
  789.         setattr(s, s, s)
  790.         self.assertEqual(getattr(s, s), s)
  791.  
  792.     
  793.     def test_iter(self):
  794.         self.assertRaises(TypeError, iter)
  795.         self.assertRaises(TypeError, iter, 42, 42)
  796.         lists = [
  797.             ('1', '2'),
  798.             [
  799.                 '1',
  800.                 '2'],
  801.             '12']
  802.         if have_unicode:
  803.             lists.append(unicode('12'))
  804.         
  805.         for l in lists:
  806.             i = iter(l)
  807.             self.assertEqual(i.next(), '1')
  808.             self.assertEqual(i.next(), '2')
  809.             self.assertRaises(StopIteration, i.next)
  810.         
  811.  
  812.     
  813.     def test_isinstance(self):
  814.         
  815.         class C:
  816.             pass
  817.  
  818.         
  819.         class D(C):
  820.             pass
  821.  
  822.         
  823.         class E:
  824.             pass
  825.  
  826.         c = C()
  827.         d = D()
  828.         e = E()
  829.         self.assert_(isinstance(c, C))
  830.         self.assert_(isinstance(d, C))
  831.         self.assert_(not isinstance(e, C))
  832.         self.assert_(not isinstance(c, D))
  833.         self.assert_(not isinstance('foo', E))
  834.         self.assertRaises(TypeError, isinstance, E, 'foo')
  835.         self.assertRaises(TypeError, isinstance)
  836.  
  837.     
  838.     def test_issubclass(self):
  839.         
  840.         class C:
  841.             pass
  842.  
  843.         
  844.         class D(C):
  845.             pass
  846.  
  847.         
  848.         class E:
  849.             pass
  850.  
  851.         c = C()
  852.         d = D()
  853.         e = E()
  854.         self.assert_(issubclass(D, C))
  855.         self.assert_(issubclass(C, C))
  856.         self.assert_(not issubclass(C, D))
  857.         self.assertRaises(TypeError, issubclass, 'foo', E)
  858.         self.assertRaises(TypeError, issubclass, E, 'foo')
  859.         self.assertRaises(TypeError, issubclass)
  860.  
  861.     
  862.     def test_len(self):
  863.         self.assertEqual(len('123'), 3)
  864.         self.assertEqual(len(()), 0)
  865.         self.assertEqual(len((1, 2, 3, 4)), 4)
  866.         self.assertEqual(len([
  867.             1,
  868.             2,
  869.             3,
  870.             4]), 4)
  871.         self.assertEqual(len({ }), 0)
  872.         self.assertEqual(len({
  873.             'a': 1,
  874.             'b': 2 }), 2)
  875.         
  876.         class BadSeq:
  877.             
  878.             def __len__(self):
  879.                 raise ValueError
  880.  
  881.  
  882.         self.assertRaises(ValueError, len, BadSeq())
  883.  
  884.     
  885.     def test_list(self):
  886.         self.assertEqual(list([]), [])
  887.         l0_3 = [
  888.             0,
  889.             1,
  890.             2,
  891.             3]
  892.         l0_3_bis = list(l0_3)
  893.         self.assertEqual(l0_3, l0_3_bis)
  894.         self.assert_(l0_3 is not l0_3_bis)
  895.         self.assertEqual(list(()), [])
  896.         self.assertEqual(list((0, 1, 2, 3)), [
  897.             0,
  898.             1,
  899.             2,
  900.             3])
  901.         self.assertEqual(list(''), [])
  902.         self.assertEqual(list('spam'), [
  903.             's',
  904.             'p',
  905.             'a',
  906.             'm'])
  907.         if sys.maxint == 2147483647:
  908.             self.assertRaises(MemoryError, list, xrange(sys.maxint // 2))
  909.         
  910.         x = []
  911.         x.extend((lambda [outmost-iterable]: for y in [outmost-iterable]:
  912. -y)(x))
  913.         self.assertEqual(x, [])
  914.  
  915.     
  916.     def test_long(self):
  917.         self.assertEqual(long(314), 0x13AL)
  918.         self.assertEqual(long(3.1400000000000001), 0x3L)
  919.         self.assertEqual(long(0x13AL), 0x13AL)
  920.         self.assertEqual(long(-3.1400000000000001), -0x3L)
  921.         self.assertEqual(long(3.8999999999999999), 0x3L)
  922.         self.assertEqual(long(-3.8999999999999999), -0x3L)
  923.         self.assertEqual(long(3.5), 0x3L)
  924.         self.assertEqual(long(-3.5), -0x3L)
  925.         self.assertEqual(long('-3'), -0x3L)
  926.         if have_unicode:
  927.             self.assertEqual(long(unicode('-3')), -0x3L)
  928.         
  929.         self.assertEqual(long('10', 16), 0x10L)
  930.         if have_unicode:
  931.             self.assertEqual(long(unicode('10'), 16), 0x10L)
  932.         
  933.         LL = [
  934.             ('1' + '0' * 20, 0xAL ** 20),
  935.             ('1' + '0' * 100, 0xAL ** 100)]
  936.         L2 = L[:]
  937.         if have_unicode:
  938.             L2 += [
  939.                 (unicode('1') + unicode('0') * 20, 0xAL ** 20),
  940.                 (unicode('1') + unicode('0') * 100, 0xAL ** 100)]
  941.         
  942.         for s, v in L2 + LL:
  943.             for sign in ('', '+', '-'):
  944.                 for prefix in ('', ' ', '\t', '  \t\t  '):
  945.                     ss = prefix + sign + s
  946.                     vv = v
  947.                     if sign == '-' and v is not ValueError:
  948.                         vv = -v
  949.                     
  950.                     
  951.                     try:
  952.                         self.assertEqual(long(ss), long(vv))
  953.                     continue
  954.                     except v:
  955.                         continue
  956.                     
  957.  
  958.                 
  959.             
  960.         
  961.         self.assertRaises(ValueError, long, '123\x00')
  962.         self.assertRaises(ValueError, long, '53', 40)
  963.         self.assertRaises(TypeError, long, 1, 12)
  964.  
  965.     
  966.     def test_map(self):
  967.         self.assertEqual(map(None, 'hello world'), [
  968.             'h',
  969.             'e',
  970.             'l',
  971.             'l',
  972.             'o',
  973.             ' ',
  974.             'w',
  975.             'o',
  976.             'r',
  977.             'l',
  978.             'd'])
  979.         self.assertEqual(map(None, 'abcd', 'efg'), [
  980.             ('a', 'e'),
  981.             ('b', 'f'),
  982.             ('c', 'g'),
  983.             ('d', None)])
  984.         self.assertEqual(map(None, range(10)), [
  985.             0,
  986.             1,
  987.             2,
  988.             3,
  989.             4,
  990.             5,
  991.             6,
  992.             7,
  993.             8,
  994.             9])
  995.         self.assertEqual(map((lambda x: x * x), range(1, 4)), [
  996.             1,
  997.             4,
  998.             9])
  999.         
  1000.         try:
  1001.             sqrt = sqrt
  1002.             import math
  1003.         except ImportError:
  1004.             
  1005.             def sqrt(x):
  1006.                 return pow(x, 0.5)
  1007.  
  1008.  
  1009.         self.assertEqual(map((lambda x: map(sqrt, x)), [
  1010.             [
  1011.                 16,
  1012.                 4],
  1013.             [
  1014.                 81,
  1015.                 9]]), [
  1016.             [
  1017.                 4.0,
  1018.                 2.0],
  1019.             [
  1020.                 9.0,
  1021.                 3.0]])
  1022.         self.assertEqual(map((lambda x, y: x + y), [
  1023.             1,
  1024.             3,
  1025.             2], [
  1026.             9,
  1027.             1,
  1028.             4]), [
  1029.             10,
  1030.             4,
  1031.             6])
  1032.         
  1033.         def plus(*v):
  1034.             accu = 0
  1035.             for i in v:
  1036.                 accu = accu + i
  1037.             
  1038.             return accu
  1039.  
  1040.         self.assertEqual(map(plus, [
  1041.             1,
  1042.             3,
  1043.             7]), [
  1044.             1,
  1045.             3,
  1046.             7])
  1047.         self.assertEqual(map(plus, [
  1048.             1,
  1049.             3,
  1050.             7], [
  1051.             4,
  1052.             9,
  1053.             2]), [
  1054.             1 + 4,
  1055.             3 + 9,
  1056.             7 + 2])
  1057.         self.assertEqual(map(plus, [
  1058.             1,
  1059.             3,
  1060.             7], [
  1061.             4,
  1062.             9,
  1063.             2], [
  1064.             1,
  1065.             1,
  1066.             0]), [
  1067.             1 + 4 + 1,
  1068.             3 + 9 + 1,
  1069.             7 + 2 + 0])
  1070.         self.assertEqual(map(None, Squares(10)), [
  1071.             0,
  1072.             1,
  1073.             4,
  1074.             9,
  1075.             16,
  1076.             25,
  1077.             36,
  1078.             49,
  1079.             64,
  1080.             81])
  1081.         self.assertEqual(map(int, Squares(10)), [
  1082.             0,
  1083.             1,
  1084.             4,
  1085.             9,
  1086.             16,
  1087.             25,
  1088.             36,
  1089.             49,
  1090.             64,
  1091.             81])
  1092.         self.assertEqual(map(None, Squares(3), Squares(2)), [
  1093.             (0, 0),
  1094.             (1, 1),
  1095.             (4, None)])
  1096.         self.assertEqual(map(max, Squares(3), Squares(2)), [
  1097.             0,
  1098.             1,
  1099.             4])
  1100.         self.assertRaises(TypeError, map)
  1101.         self.assertRaises(TypeError, map, (lambda x: x), 42)
  1102.         self.assertEqual(map(None, [
  1103.             42]), [
  1104.             42])
  1105.         
  1106.         class BadSeq:
  1107.             
  1108.             def __getitem__(self, index):
  1109.                 raise ValueError
  1110.  
  1111.  
  1112.         self.assertRaises(ValueError, map, (lambda x: x), BadSeq())
  1113.  
  1114.     
  1115.     def test_max(self):
  1116.         self.assertEqual(max('123123'), '3')
  1117.         self.assertEqual(max(1, 2, 3), 3)
  1118.         self.assertEqual(max((1, 2, 3, 1, 2, 3)), 3)
  1119.         self.assertEqual(max([
  1120.             1,
  1121.             2,
  1122.             3,
  1123.             1,
  1124.             2,
  1125.             3]), 3)
  1126.         self.assertEqual(max(1, 0x2L, 3.0), 3.0)
  1127.         self.assertEqual(max(0x1L, 2.0, 3), 3)
  1128.         self.assertEqual(max(1.0, 2, 0x3L), 0x3L)
  1129.  
  1130.     
  1131.     def test_min(self):
  1132.         self.assertEqual(min('123123'), '1')
  1133.         self.assertEqual(min(1, 2, 3), 1)
  1134.         self.assertEqual(min((1, 2, 3, 1, 2, 3)), 1)
  1135.         self.assertEqual(min([
  1136.             1,
  1137.             2,
  1138.             3,
  1139.             1,
  1140.             2,
  1141.             3]), 1)
  1142.         self.assertEqual(min(1, 0x2L, 3.0), 1)
  1143.         self.assertEqual(min(0x1L, 2.0, 3), 0x1L)
  1144.         self.assertEqual(min(1.0, 2, 0x3L), 1.0)
  1145.         self.assertRaises(TypeError, min)
  1146.         self.assertRaises(TypeError, min, 42)
  1147.         self.assertRaises(ValueError, min, ())
  1148.         
  1149.         class BadSeq:
  1150.             
  1151.             def __getitem__(self, index):
  1152.                 raise ValueError
  1153.  
  1154.  
  1155.         self.assertRaises(ValueError, min, BadSeq())
  1156.         
  1157.         class BadNumber:
  1158.             
  1159.             def __cmp__(self, other):
  1160.                 raise ValueError
  1161.  
  1162.  
  1163.         self.assertRaises(ValueError, min, (42, BadNumber()))
  1164.  
  1165.     
  1166.     def test_oct(self):
  1167.         self.assertEqual(oct(100), '0144')
  1168.         self.assertEqual(oct(0x64L), '0144L')
  1169.         self.assertEqual(oct(-100), '-0144')
  1170.         self.assertEqual(oct(-0x64L), '-0144L')
  1171.         self.assertRaises(TypeError, oct, ())
  1172.  
  1173.     
  1174.     def write_testfile(self):
  1175.         fp = open(TESTFN, 'w')
  1176.         
  1177.         try:
  1178.             fp.write('1+1\n')
  1179.             fp.write('1+1\n')
  1180.             fp.write('The quick brown fox jumps over the lazy dog')
  1181.             fp.write('.\n')
  1182.             fp.write('Dear John\n')
  1183.             fp.write('XXX' * 100)
  1184.             fp.write('YYY' * 100)
  1185.         finally:
  1186.             fp.close()
  1187.  
  1188.  
  1189.     
  1190.     def test_open(self):
  1191.         self.write_testfile()
  1192.         fp = open(TESTFN, 'r')
  1193.         
  1194.         try:
  1195.             self.assertEqual(fp.readline(4), '1+1\n')
  1196.             self.assertEqual(fp.readline(4), '1+1\n')
  1197.             self.assertEqual(fp.readline(), 'The quick brown fox jumps over the lazy dog.\n')
  1198.             self.assertEqual(fp.readline(4), 'Dear')
  1199.             self.assertEqual(fp.readline(100), ' John\n')
  1200.             self.assertEqual(fp.read(300), 'XXX' * 100)
  1201.             self.assertEqual(fp.read(1000), 'YYY' * 100)
  1202.         finally:
  1203.             fp.close()
  1204.  
  1205.         unlink(TESTFN)
  1206.  
  1207.     
  1208.     def test_ord(self):
  1209.         self.assertEqual(ord(' '), 32)
  1210.         self.assertEqual(ord('A'), 65)
  1211.         self.assertEqual(ord('a'), 97)
  1212.         if have_unicode:
  1213.             self.assertEqual(ord(unichr(sys.maxunicode)), sys.maxunicode)
  1214.         
  1215.         self.assertRaises(TypeError, ord, 42)
  1216.         self.assertRaises(TypeError, ord, unicode('12'))
  1217.  
  1218.     
  1219.     def test_pow(self):
  1220.         self.assertEqual(pow(0, 0), 1)
  1221.         self.assertEqual(pow(0, 1), 0)
  1222.         self.assertEqual(pow(1, 0), 1)
  1223.         self.assertEqual(pow(1, 1), 1)
  1224.         self.assertEqual(pow(2, 0), 1)
  1225.         self.assertEqual(pow(2, 10), 1024)
  1226.         self.assertEqual(pow(2, 20), 1024 * 1024)
  1227.         self.assertEqual(pow(2, 30), 1024 * 1024 * 1024)
  1228.         self.assertEqual(pow(-2, 0), 1)
  1229.         self.assertEqual(pow(-2, 1), -2)
  1230.         self.assertEqual(pow(-2, 2), 4)
  1231.         self.assertEqual(pow(-2, 3), -8)
  1232.         self.assertEqual(pow(0x0L, 0), 1)
  1233.         self.assertEqual(pow(0x0L, 1), 0)
  1234.         self.assertEqual(pow(0x1L, 0), 1)
  1235.         self.assertEqual(pow(0x1L, 1), 1)
  1236.         self.assertEqual(pow(0x2L, 0), 1)
  1237.         self.assertEqual(pow(0x2L, 10), 1024)
  1238.         self.assertEqual(pow(0x2L, 20), 1024 * 1024)
  1239.         self.assertEqual(pow(0x2L, 30), 1024 * 1024 * 1024)
  1240.         self.assertEqual(pow(-0x2L, 0), 1)
  1241.         self.assertEqual(pow(-0x2L, 1), -2)
  1242.         self.assertEqual(pow(-0x2L, 2), 4)
  1243.         self.assertEqual(pow(-0x2L, 3), -8)
  1244.         self.assertAlmostEqual(pow(0.0, 0), 1.0)
  1245.         self.assertAlmostEqual(pow(0.0, 1), 0.0)
  1246.         self.assertAlmostEqual(pow(1.0, 0), 1.0)
  1247.         self.assertAlmostEqual(pow(1.0, 1), 1.0)
  1248.         self.assertAlmostEqual(pow(2.0, 0), 1.0)
  1249.         self.assertAlmostEqual(pow(2.0, 10), 1024.0)
  1250.         self.assertAlmostEqual(pow(2.0, 20), 1024.0 * 1024.0)
  1251.         self.assertAlmostEqual(pow(2.0, 30), 1024.0 * 1024.0 * 1024.0)
  1252.         self.assertAlmostEqual(pow(-2.0, 0), 1.0)
  1253.         self.assertAlmostEqual(pow(-2.0, 1), -2.0)
  1254.         self.assertAlmostEqual(pow(-2.0, 2), 4.0)
  1255.         self.assertAlmostEqual(pow(-2.0, 3), -8.0)
  1256.         for x in (2, 0x2L, 2.0):
  1257.             for y in (10, 0xAL, 10.0):
  1258.                 for z in (1000, 0x3E8L, 1000.0):
  1259.                     if isinstance(x, float) and isinstance(y, float) or isinstance(z, float):
  1260.                         self.assertRaises(TypeError, pow, x, y, z)
  1261.                         continue
  1262.                     self.assertAlmostEqual(pow(x, y, z), 24.0)
  1263.                 
  1264.             
  1265.         
  1266.         self.assertRaises(TypeError, pow, -1, -2, 3)
  1267.         self.assertRaises(ValueError, pow, 1, 2, 0)
  1268.         self.assertRaises(TypeError, pow, -0x1L, -0x2L, 0x3L)
  1269.         self.assertRaises(ValueError, pow, 0x1L, 0x2L, 0x0L)
  1270.         self.assertRaises(ValueError, pow, -342.43000000000001, 0.23400000000000001)
  1271.         self.assertRaises(TypeError, pow)
  1272.  
  1273.     
  1274.     def test_range(self):
  1275.         self.assertEqual(range(3), [
  1276.             0,
  1277.             1,
  1278.             2])
  1279.         self.assertEqual(range(1, 5), [
  1280.             1,
  1281.             2,
  1282.             3,
  1283.             4])
  1284.         self.assertEqual(range(0), [])
  1285.         self.assertEqual(range(-3), [])
  1286.         self.assertEqual(range(1, 10, 3), [
  1287.             1,
  1288.             4,
  1289.             7])
  1290.         self.assertEqual(range(5, -5, -3), [
  1291.             5,
  1292.             2,
  1293.             -1,
  1294.             -4])
  1295.         self.assertEqual(range(-2 ** 100), [])
  1296.         self.assertEqual(range(0, -2 ** 100), [])
  1297.         self.assertEqual(range(0, 2 ** 100, -1), [])
  1298.         self.assertEqual(range(0, 2 ** 100, -1), [])
  1299.         a = long(10 * sys.maxint)
  1300.         b = long(100 * sys.maxint)
  1301.         c = long(50 * sys.maxint)
  1302.         self.assertEqual(range(a, a + 2), [
  1303.             a,
  1304.             a + 1])
  1305.         self.assertEqual(range(a + 2, a, -0x1L), [
  1306.             a + 2,
  1307.             a + 1])
  1308.         self.assertEqual(range(a + 4, a, -2), [
  1309.             a + 4,
  1310.             a + 2])
  1311.         seq = range(a, b, c)
  1312.         self.assert_(a in seq)
  1313.         self.assert_(b not in seq)
  1314.         self.assertEqual(len(seq), 2)
  1315.         seq = range(b, a, -c)
  1316.         self.assert_(b in seq)
  1317.         self.assert_(a not in seq)
  1318.         self.assertEqual(len(seq), 2)
  1319.         seq = range(-a, -b, -c)
  1320.         self.assert_(-a in seq)
  1321.         self.assert_(-b not in seq)
  1322.         self.assertEqual(len(seq), 2)
  1323.         self.assertRaises(TypeError, range)
  1324.         self.assertRaises(TypeError, range, 1, 2, 3, 4)
  1325.         self.assertRaises(ValueError, range, 1, 2, 0)
  1326.         self.assertRaises(TypeError, range, 1e+100, 9.9999999999999998e+100, 9.9999999999999998e+100)
  1327.         self.assertRaises(TypeError, range, 0, 'spam')
  1328.         self.assertRaises(TypeError, range, 0, 42, 'spam')
  1329.         self.assertRaises(OverflowError, range, -(sys.maxint), sys.maxint)
  1330.         self.assertRaises(OverflowError, range, 0, 2 * sys.maxint)
  1331.  
  1332.     
  1333.     def test_input_and_raw_input(self):
  1334.         self.write_testfile()
  1335.         fp = open(TESTFN, 'r')
  1336.         savestdin = sys.stdin
  1337.         savestdout = sys.stdout
  1338.         
  1339.         try:
  1340.             sys.stdin = fp
  1341.             sys.stdout = BitBucket()
  1342.             self.assertEqual(input(), 2)
  1343.             self.assertEqual(input('testing\n'), 2)
  1344.             self.assertEqual(raw_input(), 'The quick brown fox jumps over the lazy dog.')
  1345.             self.assertEqual(raw_input('testing\n'), 'Dear John')
  1346.             sys.stdin = cStringIO.StringIO('NULL\x00')
  1347.             self.assertRaises(TypeError, input, 42, 42)
  1348.             sys.stdin = cStringIO.StringIO("    'whitespace'")
  1349.             self.assertEqual(input(), 'whitespace')
  1350.             sys.stdin = cStringIO.StringIO()
  1351.             self.assertRaises(EOFError, input)
  1352.             sys.stdin = cStringIO.StringIO('1/2')
  1353.             sys.stdout = cStringIO.StringIO()
  1354.             exec compile('print input()', 'test_builtin_tmp', 'exec')
  1355.             sys.stdin.seek(0, 0)
  1356.             exec compile('from __future__ import division;print input()', 'test_builtin_tmp', 'exec')
  1357.             sys.stdin.seek(0, 0)
  1358.             exec compile('print input()', 'test_builtin_tmp', 'exec')
  1359.             self.assertEqual(sys.stdout.getvalue().splitlines(), [
  1360.                 '0',
  1361.                 '0.5',
  1362.                 '0'])
  1363.             del sys.stdout
  1364.             self.assertRaises(RuntimeError, input, 'prompt')
  1365.             del sys.stdin
  1366.             self.assertRaises(RuntimeError, input, 'prompt')
  1367.         finally:
  1368.             sys.stdin = savestdin
  1369.             sys.stdout = savestdout
  1370.             fp.close()
  1371.             unlink(TESTFN)
  1372.  
  1373.  
  1374.     
  1375.     def test_reduce(self):
  1376.         self.assertEqual(reduce((lambda x, y: x + y), [
  1377.             'a',
  1378.             'b',
  1379.             'c'], ''), 'abc')
  1380.         self.assertEqual(reduce((lambda x, y: x + y), [
  1381.             [
  1382.                 'a',
  1383.                 'c'],
  1384.             [],
  1385.             [
  1386.                 'd',
  1387.                 'w']], []), [
  1388.             'a',
  1389.             'c',
  1390.             'd',
  1391.             'w'])
  1392.         self.assertEqual(reduce((lambda x, y: x * y), range(2, 8), 1), 5040)
  1393.         self.assertEqual(reduce((lambda x, y: x * y), range(2, 21), 0x1L), 0x21C3677C82B40000L)
  1394.         self.assertEqual(reduce((lambda x, y: x + y), Squares(10)), 285)
  1395.         self.assertEqual(reduce((lambda x, y: x + y), Squares(10), 0), 285)
  1396.         self.assertEqual(reduce((lambda x, y: x + y), Squares(0), 0), 0)
  1397.         self.assertRaises(TypeError, reduce)
  1398.         self.assertRaises(TypeError, reduce, 42, 42)
  1399.         self.assertRaises(TypeError, reduce, 42, 42, 42)
  1400.         self.assertEqual(reduce(42, '1'), '1')
  1401.         self.assertEqual(reduce(42, '', '1'), '1')
  1402.         self.assertRaises(TypeError, reduce, 42, (42, 42))
  1403.         
  1404.         class BadSeq:
  1405.             
  1406.             def __getitem__(self, index):
  1407.                 raise ValueError
  1408.  
  1409.  
  1410.         self.assertRaises(ValueError, reduce, 42, BadSeq())
  1411.  
  1412.     
  1413.     def test_reload(self):
  1414.         import marshal
  1415.         reload(marshal)
  1416.         import string
  1417.         reload(string)
  1418.  
  1419.     
  1420.     def test_repr(self):
  1421.         self.assertEqual(repr(''), "''")
  1422.         self.assertEqual(repr(0), '0')
  1423.         self.assertEqual(repr(0x0L), '0L')
  1424.         self.assertEqual(repr(()), '()')
  1425.         self.assertEqual(repr([]), '[]')
  1426.         self.assertEqual(repr({ }), '{}')
  1427.         a = []
  1428.         a.append(a)
  1429.         self.assertEqual(repr(a), '[[...]]')
  1430.         a = { }
  1431.         a[0] = a
  1432.         self.assertEqual(repr(a), '{0: {...}}')
  1433.  
  1434.     
  1435.     def test_round(self):
  1436.         self.assertEqual(round(0.0), 0.0)
  1437.         self.assertEqual(round(1.0), 1.0)
  1438.         self.assertEqual(round(10.0), 10.0)
  1439.         self.assertEqual(round(1000000000.0), 1000000000.0)
  1440.         self.assertEqual(round(1e+20), 1e+20)
  1441.         self.assertEqual(round(-1.0), -1.0)
  1442.         self.assertEqual(round(-10.0), -10.0)
  1443.         self.assertEqual(round(-1000000000.0), -1000000000.0)
  1444.         self.assertEqual(round(-1e+20), -1e+20)
  1445.         self.assertEqual(round(0.10000000000000001), 0.0)
  1446.         self.assertEqual(round(1.1000000000000001), 1.0)
  1447.         self.assertEqual(round(10.1), 10.0)
  1448.         self.assertEqual(round(1000000000.1), 1000000000.0)
  1449.         self.assertEqual(round(-1.1000000000000001), -1.0)
  1450.         self.assertEqual(round(-10.1), -10.0)
  1451.         self.assertEqual(round(-1000000000.1), -1000000000.0)
  1452.         self.assertEqual(round(0.90000000000000002), 1.0)
  1453.         self.assertEqual(round(9.9000000000000004), 10.0)
  1454.         self.assertEqual(round(999999999.89999998), 1000000000.0)
  1455.         self.assertEqual(round(-0.90000000000000002), -1.0)
  1456.         self.assertEqual(round(-9.9000000000000004), -10.0)
  1457.         self.assertEqual(round(-999999999.89999998), -1000000000.0)
  1458.         self.assertEqual(round(-8.0, -1), -10.0)
  1459.         self.assertRaises(TypeError, round)
  1460.  
  1461.     
  1462.     def test_setattr(self):
  1463.         setattr(sys, 'spam', 1)
  1464.         self.assertEqual(sys.spam, 1)
  1465.         self.assertRaises(TypeError, setattr, sys, 1, 'spam')
  1466.         self.assertRaises(TypeError, setattr)
  1467.  
  1468.     
  1469.     def test_str(self):
  1470.         self.assertEqual(str(''), '')
  1471.         self.assertEqual(str(0), '0')
  1472.         self.assertEqual(str(0x0L), '0')
  1473.         self.assertEqual(str(()), '()')
  1474.         self.assertEqual(str([]), '[]')
  1475.         self.assertEqual(str({ }), '{}')
  1476.         a = []
  1477.         a.append(a)
  1478.         self.assertEqual(str(a), '[[...]]')
  1479.         a = { }
  1480.         a[0] = a
  1481.         self.assertEqual(str(a), '{0: {...}}')
  1482.  
  1483.     
  1484.     def test_sum(self):
  1485.         self.assertEqual(sum([]), 0)
  1486.         self.assertEqual(sum(range(2, 8)), 27)
  1487.         self.assertEqual(sum(iter(range(2, 8))), 27)
  1488.         self.assertEqual(sum(Squares(10)), 285)
  1489.         self.assertEqual(sum(iter(Squares(10))), 285)
  1490.         self.assertEqual(sum([
  1491.             [
  1492.                 1],
  1493.             [
  1494.                 2],
  1495.             [
  1496.                 3]], []), [
  1497.             1,
  1498.             2,
  1499.             3])
  1500.         self.assertRaises(TypeError, sum)
  1501.         self.assertRaises(TypeError, sum, 42)
  1502.         self.assertRaises(TypeError, sum, [
  1503.             'a',
  1504.             'b',
  1505.             'c'])
  1506.         self.assertRaises(TypeError, sum, [
  1507.             'a',
  1508.             'b',
  1509.             'c'], '')
  1510.         self.assertRaises(TypeError, sum, [
  1511.             [
  1512.                 1],
  1513.             [
  1514.                 2],
  1515.             [
  1516.                 3]])
  1517.         self.assertRaises(TypeError, sum, [
  1518.             {
  1519.                 2: 3 }])
  1520.         self.assertRaises(TypeError, sum, [
  1521.             {
  1522.                 2: 3 }] * 2, {
  1523.             2: 3 })
  1524.         
  1525.         class BadSeq:
  1526.             
  1527.             def __getitem__(self, index):
  1528.                 raise ValueError
  1529.  
  1530.  
  1531.         self.assertRaises(ValueError, sum, BadSeq())
  1532.  
  1533.     
  1534.     def test_tuple(self):
  1535.         self.assertEqual(tuple(()), ())
  1536.         t0_3 = (0, 1, 2, 3)
  1537.         t0_3_bis = tuple(t0_3)
  1538.         self.assert_(t0_3 is t0_3_bis)
  1539.         self.assertEqual(tuple([]), ())
  1540.         self.assertEqual(tuple([
  1541.             0,
  1542.             1,
  1543.             2,
  1544.             3]), (0, 1, 2, 3))
  1545.         self.assertEqual(tuple(''), ())
  1546.         self.assertEqual(tuple('spam'), ('s', 'p', 'a', 'm'))
  1547.  
  1548.     
  1549.     def test_type(self):
  1550.         self.assertEqual(type(''), type('123'))
  1551.         self.assertNotEqual(type(''), type(()))
  1552.  
  1553.     
  1554.     def test_unichr(self):
  1555.         if have_unicode:
  1556.             self.assertEqual(unichr(32), unicode(' '))
  1557.             self.assertEqual(unichr(65), unicode('A'))
  1558.             self.assertEqual(unichr(97), unicode('a'))
  1559.             self.assertEqual(unichr(sys.maxunicode), unicode('\\U%08x' % sys.maxunicode, 'unicode-escape'))
  1560.             self.assertRaises(ValueError, unichr, sys.maxunicode + 1)
  1561.             self.assertRaises(TypeError, unichr)
  1562.         
  1563.  
  1564.     
  1565.     def get_vars_f0():
  1566.         return vars()
  1567.  
  1568.     get_vars_f0 = staticmethod(get_vars_f0)
  1569.     
  1570.     def get_vars_f2():
  1571.         BuiltinTest.get_vars_f0()
  1572.         a = 1
  1573.         b = 2
  1574.         return vars()
  1575.  
  1576.     get_vars_f2 = staticmethod(get_vars_f2)
  1577.     
  1578.     def test_vars(self):
  1579.         self.assertEqual(set(vars()), set(dir()))
  1580.         import sys
  1581.         self.assertEqual(set(vars(sys)), set(dir(sys)))
  1582.         self.assertEqual(self.get_vars_f0(), { })
  1583.         self.assertEqual(self.get_vars_f2(), {
  1584.             'a': 1,
  1585.             'b': 2 })
  1586.         self.assertRaises(TypeError, vars, 42, 42)
  1587.         self.assertRaises(TypeError, vars, 42)
  1588.  
  1589.     
  1590.     def test_zip(self):
  1591.         a = (1, 2, 3)
  1592.         b = (4, 5, 6)
  1593.         t = [
  1594.             (1, 4),
  1595.             (2, 5),
  1596.             (3, 6)]
  1597.         self.assertEqual(zip(a, b), t)
  1598.         b = [
  1599.             4,
  1600.             5,
  1601.             6]
  1602.         self.assertEqual(zip(a, b), t)
  1603.         b = (4, 5, 6, 7)
  1604.         self.assertEqual(zip(a, b), t)
  1605.         
  1606.         class I:
  1607.             
  1608.             def __getitem__(self, i):
  1609.                 if i < 0 or i > 2:
  1610.                     raise IndexError
  1611.                 
  1612.                 return i + 4
  1613.  
  1614.  
  1615.         self.assertEqual(zip(a, I()), t)
  1616.         self.assertEqual(zip(), [])
  1617.         self.assertEqual(zip(*[]), [])
  1618.         self.assertRaises(TypeError, zip, None)
  1619.         
  1620.         class G:
  1621.             pass
  1622.  
  1623.         self.assertRaises(TypeError, zip, a, G())
  1624.         
  1625.         class SequenceWithoutALength:
  1626.             
  1627.             def __getitem__(self, i):
  1628.                 if i == 5:
  1629.                     raise IndexError
  1630.                 else:
  1631.                     return i
  1632.  
  1633.  
  1634.         self.assertEqual(zip(SequenceWithoutALength(), xrange(2 ** 30)), list(enumerate(range(5))))
  1635.         
  1636.         class BadSeq:
  1637.             
  1638.             def __getitem__(self, i):
  1639.                 if i == 5:
  1640.                     raise ValueError
  1641.                 else:
  1642.                     return i
  1643.  
  1644.  
  1645.         self.assertRaises(ValueError, zip, BadSeq(), BadSeq())
  1646.  
  1647.  
  1648.  
  1649. class TestSorted(unittest.TestCase):
  1650.     
  1651.     def test_basic(self):
  1652.         data = range(100)
  1653.         copy = data[:]
  1654.         random.shuffle(copy)
  1655.         self.assertEqual(data, sorted(copy))
  1656.         self.assertNotEqual(data, copy)
  1657.         data.reverse()
  1658.         random.shuffle(copy)
  1659.         self.assertEqual(data, sorted(copy, cmp = (lambda x, y: cmp(y, x))))
  1660.         self.assertNotEqual(data, copy)
  1661.         random.shuffle(copy)
  1662.         self.assertEqual(data, sorted(copy, key = (lambda x: -x)))
  1663.         self.assertNotEqual(data, copy)
  1664.         random.shuffle(copy)
  1665.         self.assertEqual(data, sorted(copy, reverse = 1))
  1666.         self.assertNotEqual(data, copy)
  1667.  
  1668.     
  1669.     def test_inputtypes(self):
  1670.         s = 'abracadabra'
  1671.         for T in [
  1672.             unicode,
  1673.             list,
  1674.             tuple]:
  1675.             self.assertEqual(sorted(s), sorted(T(s)))
  1676.         
  1677.         s = ''.join(dict.fromkeys(s).keys())
  1678.         for T in [
  1679.             unicode,
  1680.             set,
  1681.             frozenset,
  1682.             list,
  1683.             tuple,
  1684.             dict.fromkeys]:
  1685.             self.assertEqual(sorted(s), sorted(T(s)))
  1686.         
  1687.  
  1688.     
  1689.     def test_baddecorator(self):
  1690.         data = 'The quick Brown fox Jumped over The lazy Dog'.split()
  1691.         self.assertRaises(TypeError, sorted, data, None, (lambda x, y: 0))
  1692.  
  1693.  
  1694.  
  1695. def test_main():
  1696.     test.test_support.run_unittest(BuiltinTest, TestSorted)
  1697.  
  1698. if __name__ == '__main__':
  1699.     test_main()
  1700.  
  1701.